home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / BEERSRC.ZIP / COMBINER.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-26  |  7.7 KB  |  370 lines
  1.  
  2. #ifndef __COMPACT__ || __LARGE__
  3.    #error NEED FAR DATA POINTERS
  4. #endif
  5.  
  6. #include <stdio.h>
  7. #include <sys\stat.h>
  8. #include <io.h>
  9. #include <fcntl.h>
  10. #include <string.h>
  11. #include <alloc.h>
  12. #include <dir.h>
  13. #include <stdlib.h>
  14.  
  15.  
  16. #include "fileman.h"
  17.  
  18. #define HDRTEXTSIZE        30
  19. #define MAXFILES        200
  20.  
  21.  
  22. struct filestrc {
  23.    char  name[14];        // Name of file.
  24.    long  size;            // It's size.
  25.    int   flags;            // Buffering flags.
  26.    long  fptr;            // File pointer to access it's data.
  27. };
  28.  
  29.  
  30. const char hdrtext[HDRTEXTSIZE] = "ALPHA-HELIX COMBINER VER 3.3\x1a";
  31.  
  32. char   libfile[80];
  33. int    libfilvar;
  34. long   libsize;
  35. int    nfiles;
  36. int    mode;
  37. struct filestrc file[MAXFILES];
  38.  
  39. long   objsize;
  40.  
  41. int openlib(char *txt)
  42. {
  43.    long size;
  44.    char huge *ptr;
  45.  
  46.    libfilvar = open(txt, O_RDONLY | O_BINARY, S_IREAD);
  47.    if (libfilvar == -1) {
  48.       nfiles = 0; libsize = 0; mode = 0;
  49.    } else {
  50.       lseek(libfilvar, HDRTEXTSIZE, SEEK_SET);
  51.       read(libfilvar, &mode, 2);
  52.       read(libfilvar, &nfiles, 2);
  53.       libsize = filelength(libfilvar)-HDRTEXTSIZE-4-nfiles*sizeof(struct filestrc);
  54.       read(libfilvar, file, nfiles*sizeof(struct filestrc));
  55.    }
  56.  
  57.    return 0;
  58.  
  59. }
  60.  
  61.  
  62.  
  63. int addfile(char *txt, int flags)
  64. {
  65.    int   filvar;
  66.    int   obj;
  67.    char  name[MAXFILE+MAXEXT];
  68.    char  ext[MAXEXT];
  69.    long  size;
  70.    char  huge *ptr;
  71.    int   i;
  72.  
  73.  
  74.    if (openlib(libfile) == -1) return -1;
  75.  
  76.    obj = open(txt, O_RDONLY | O_BINARY, S_IREAD);
  77.    if (obj == -1) {
  78.       close(libfilvar);
  79.       perror("openobj : ");
  80.       return -1;
  81.    }
  82.    objsize = filelength(obj);
  83.  
  84.    filvar = open("COMB.TMP", O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IWRITE);
  85.    if (filvar == -1) {
  86.       close(libfilvar);
  87.       perror("addfile");
  88.       return -1;
  89.    }
  90.    _splitpath(txt, NULL, NULL, name, ext);
  91.    strcat(name, ext);
  92.    strcpy(file[nfiles].name, strupr(name));
  93.    file[nfiles].size = objsize;
  94.    file[nfiles].flags = flags;
  95.  
  96. // Write Header.
  97.    write(filvar, hdrtext, HDRTEXTSIZE);
  98.    write(filvar, &mode, 2);
  99.    nfiles++;
  100.    write(filvar, &nfiles, 2);
  101.  
  102. // Write directory.
  103.    for (i = 0; i < nfiles-1; i++) {
  104.       file[i].fptr += sizeof(struct filestrc);
  105.    }
  106.    file[nfiles-1].fptr = libsize+HDRTEXTSIZE+4+nfiles*sizeof(struct filestrc);
  107.    write(filvar, file, nfiles*sizeof(struct filestrc));
  108.  
  109. // Write old data.
  110.    if ((ptr = farmalloc(65000l)) == NULL) {
  111.       close(libfilvar);
  112.       return -1;
  113.    }
  114.    size = libsize;
  115.    while(size > 65000) {
  116.       read(libfilvar, ptr, 65000);
  117.       write(filvar, ptr, 65000);
  118.       size -= 65000;
  119.    }
  120.    read(libfilvar, ptr, size);
  121.    write(filvar, ptr, size);
  122.  
  123. // Write new object.
  124.    size = objsize;
  125.    while(size > 65000) {
  126.       read(obj, ptr, 65000);
  127.       write(filvar, ptr, 65000);
  128.       size -= 65000;
  129.    }
  130.    read(obj, ptr, size);
  131.    write(filvar, ptr, size);
  132.    farfree(ptr);
  133.  
  134.    close(filvar);
  135.    close(obj);
  136.    close(libfilvar);
  137.    remove(libfile);
  138.    rename("COMB.TMP", libfile);
  139.  
  140.    return 0;
  141. }
  142.  
  143.  
  144. int deletefile(char *txt)
  145. {
  146.    int   i, j;
  147.    int   filvar;
  148.    long  size, size1, size2;
  149.    long  fptr1, fptr2;
  150.    void  *ptr;
  151.  
  152.  
  153.    if (openlib(libfile) == -1) return -1;
  154.    strupr(txt);
  155.    for (i = 0; i < nfiles; i++) {
  156.       if (strcmp(txt, file[i].name) == 0) {
  157.      filvar = open("COMB.TMP", O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IWRITE);
  158.      if (filvar == -1) {
  159.         close(libfilvar);
  160.         perror("addfile");
  161.         return -1;
  162.      }
  163.  
  164. // Write Header.
  165.      write(filvar, hdrtext, HDRTEXTSIZE);
  166.      write(filvar, &mode, 2);
  167.      nfiles--;
  168.      write(filvar, &nfiles, 2);
  169. // Write directory.
  170.      size = file[i].size;
  171.      fptr1 = file[0].fptr;
  172.      fptr2 = file[i+1].fptr;
  173.      size1 = size2 = 0;
  174.      for (j = 0; j < nfiles; j++) {
  175.         if (j < i) {
  176.            size1 += file[j].size;
  177.            file[j].fptr -= sizeof(struct filestrc);
  178.         } else {
  179.            file[j] = file[j+1];
  180.            file[j].fptr -= (sizeof(struct filestrc) + size);
  181.            size2 += file[j].size;
  182.         }
  183.      }
  184.      if (size+size1+size2 != libsize) abort();
  185.      write(filvar, file, nfiles*sizeof(struct filestrc));
  186.  
  187. // Write data.
  188.      if ((ptr = farmalloc(65000l)) == NULL) {
  189.         close(libfilvar);
  190.         return -1;
  191.      }
  192.      lseek(libfilvar, fptr1, SEEK_SET);
  193.      while(size1 > 65000) {
  194.         read(libfilvar, ptr, 65000);
  195.         write(filvar, ptr, 65000);
  196.         size1 -= 65000;
  197.      }
  198.      read(libfilvar, ptr, size1);
  199.      write(filvar, ptr, size1);
  200.  
  201.      lseek(libfilvar, fptr2, SEEK_SET);
  202.      while(size2 > 65000) {
  203.         read(libfilvar, ptr, 65000);
  204.         write(filvar, ptr, 65000);
  205.         size2 -= 65000;
  206.      }
  207.      read(libfilvar, ptr, size2);
  208.      write(filvar, ptr, size2);
  209.  
  210.      farfree(ptr);
  211.  
  212.      close(filvar);
  213.      remove(libfile);
  214.      rename("COMB.TMP", libfile);
  215.      break;
  216.  
  217.       }
  218.    }
  219.    close(libfilvar);
  220.  
  221.    return 0;
  222.  
  223. }
  224.  
  225. int extractfile(char *txt)
  226. {
  227.    int   i, j;
  228.    int   filvar;
  229.    long  size, size1, size2;
  230.    long  fptr1;
  231.    void  *ptr;
  232.  
  233.  
  234.    if (openlib(libfile) == -1) return -1;
  235.    strupr(txt);
  236.    for (i = 0; i < nfiles; i++) {
  237.       if (strcmp(txt, file[i].name) == 0) {
  238.      filvar = open(txt, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IWRITE);
  239.      if (filvar == -1) {
  240.         close(libfilvar);
  241.         perror("extractfile");
  242.         return -1;
  243.      }
  244.  
  245.      size = file[i].size;
  246.      fptr1 = file[i].fptr;
  247.  
  248. // Write data.
  249.      if ((ptr = farmalloc(65000l)) == NULL) {
  250.         close(libfilvar);
  251.         return -1;
  252.      }
  253.      lseek(libfilvar, fptr1, SEEK_SET);
  254.      while(size > 65000) {
  255.         read(libfilvar, ptr, 65000);
  256.         write(filvar, ptr, 65000);
  257.         size -= 65000;
  258.      }
  259.      read(libfilvar, ptr, size);
  260.      write(filvar, ptr, size);
  261.  
  262.      farfree(ptr);
  263.  
  264.      close(filvar);
  265.       }
  266.    }
  267.    close(libfilvar);
  268.  
  269.    return 0;
  270.  
  271. }
  272.  
  273.  
  274. int showdir(int mode)
  275. {
  276.    int   i;
  277.    char  c[20];
  278.  
  279.  
  280.    if (openlib(libfile) == -1) return -1;
  281.    printf("\n");
  282.    if (mode == 0) {
  283.       for (i = 0; i < nfiles; i++) {
  284.      printf("%s  ", file[i].name);
  285.       }
  286.    } else {
  287.       for (i = 0; i < nfiles; i++) {
  288.      if (file[i].flags & M_NOFREEUP) {
  289.         strcpy(c, "No FreeUp");
  290.      } else {
  291.         strcpy(c, (file[i].flags & M_XMS) ? "XMS" : "NONE");
  292.      }
  293.  
  294.      printf("%s\t\t%s\t%lu\n", file[i].name, c, file[i].size);
  295.       }
  296.    }
  297.    printf("\n\n");
  298.    close(libfilvar);
  299.  
  300.    return 0;
  301. }
  302.  
  303.  
  304. int main(void)
  305. {
  306.    char   text[80], t[20];
  307.    int    flags;
  308.  
  309.  
  310.    printf("\nCOMBINER ver 3.3 [c] 1992, 93 by Alpha-Helix.\n\n");
  311.    printf("Command Usage:  +file  : Adds or replaces file.\n");
  312.    printf("                -file  : Deletes file from library.\n");
  313.    printf("                xfile  : Extract file.\n");
  314.    printf("                d      : Directory of library.\n");
  315.    printf("                d+     : Detailed directory.\n");
  316.    printf("                .      : Finish current session.\n");
  317.    printf("\n");
  318.    printf("Library [.DAT]: ");
  319.    fflush(stdin);
  320.    scanf("%s", libfile);
  321.    strcat(libfile, ".DAT");
  322.  
  323.    do {
  324.       printf("Command: ");
  325.       fflush(stdin);
  326.       scanf("%s", text);
  327.       switch (text[0]) {
  328.  
  329.      case '+': // Add file.
  330.         flags = M_XMS;
  331.         printf("Caching: Yes, No, Only if free: [Y]: ");
  332.         fflush(stdin);
  333.         gets(t);
  334.         if (strlen(t) != 0)
  335.            switch(t[0]) {
  336.           case 'n':
  337.           case 'N': flags = M_NONE;
  338.                 break;
  339.           case 'o':
  340.           case 'O': flags = M_XMS | M_NOFREEUP;
  341.                 break;
  342.            }
  343.         deletefile(&text[1]);
  344.         addfile(&text[1], flags);
  345.         break;
  346.  
  347.      case '-': // Delete file.
  348.         deletefile(&text[1]);
  349.         break;
  350.  
  351.      case 'x': // Extract file.
  352.      case 'X':
  353.         extractfile(&text[1]);
  354.         break;
  355.  
  356.      case 'd':
  357.         if (text[1] == '+')
  358.            showdir(1);
  359.         else
  360.            showdir(0);
  361.         break;
  362.  
  363.       }
  364.  
  365.    } while (text[0] != '.');
  366.  
  367.  
  368.    return 0;
  369. }
  370.